package com.atguigu.ssyx.product.service.impl;

import com.atguigu.ssyx.model.product.SkuAttrValue;
import com.atguigu.ssyx.model.product.SkuImage;
import com.atguigu.ssyx.model.product.SkuInfo;
import com.atguigu.ssyx.model.product.SkuPoster;
import com.atguigu.ssyx.product.mapper.SkuInfoMapper;
import com.atguigu.ssyx.product.service.SkuAttrValueService;
import com.atguigu.ssyx.product.service.SkuImageService;
import com.atguigu.ssyx.product.service.SkuInfoService;
import com.atguigu.ssyx.product.service.SkuPosterService;
import com.atguigu.ssyx.rabbitmq.constant.MqConstant;
import com.atguigu.ssyx.rabbitmq.service.RabbitMQService;
import com.atguigu.ssyx.vo.product.SkuInfoQueryVo;
import com.atguigu.ssyx.vo.product.SkuInfoVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;

/**
 * <p>
 * sku信息 服务实现类
 * </p>
 *
 * @author atguigu
 * @since 2025-10-30
 */
@Service
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoMapper, SkuInfo> implements SkuInfoService {

    // sku图片
    @Resource
    private SkuImageService skuImageService;

    // sku属性
    @Resource
    private SkuAttrValueService skuAttrValueService;

    // sku海报
    @Resource
    private SkuPosterService skuPosterService;

    // MQ
    @Resource
    private RabbitMQService rabbitMQService;

    /**
     * 获取sku分页列表
     */
    @Override
    public IPage<SkuInfo> getSkuInfoPageList(Page<SkuInfo> pageParam, SkuInfoQueryVo skuInfoQueryVo) {
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotEmpty(skuInfoQueryVo.getKeyword())) {
            wrapper.like(SkuInfo::getSkuName, skuInfoQueryVo.getKeyword());
        }
        if (skuInfoQueryVo.getCategoryId() != null) {
            wrapper.eq(SkuInfo::getCategoryId, skuInfoQueryVo.getCategoryId());
        }
        if (StringUtils.isNotEmpty(skuInfoQueryVo.getSkuType())) {
            wrapper.like(SkuInfo::getSkuType, skuInfoQueryVo.getSkuType());
        }
        return baseMapper.selectPage(pageParam, wrapper);
    }

    /**
     * 保存sku信息
     */
    @Override
    @Transactional
    public void saveSkuInfo(SkuInfoVo skuInfoVo) {
        // 添加sku信息
        SkuInfo skuInfo = new SkuInfo();
        BeanUtils.copyProperties(skuInfoVo, skuInfo);
        baseMapper.insert(skuInfo);

        // 添加sku海报
        List<SkuPoster> skuPosterList = skuInfoVo.getSkuPosterList();
        if (!CollectionUtils.isEmpty(skuPosterList)) {
            // 遍历, 添加sku海报,为每个海报添加商品skuId
            for (SkuPoster skuPoster : skuPosterList) {
                skuPoster.setSkuId(skuInfo.getId());
            }
            skuPosterService.saveBatch(skuPosterList);
        }

        // 添加sku图片
        List<SkuImage> skuImageList = skuInfoVo.getSkuImagesList();
        if (!CollectionUtils.isEmpty(skuImageList)) {
            // 遍历, 添加sku图片,为每个图片添加商品skuId
            for (SkuImage skuImage : skuImageList) {
                skuImage.setSkuId(skuInfo.getId());
            }
            skuImageService.saveBatch(skuImageList);
        }

        // 添加sku属性
        List<SkuAttrValue> skuAttrValueList = skuInfoVo.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            // 遍历, 添加sku属性,为每个属性添加商品skuId
            for (SkuAttrValue skuAttrValue : skuAttrValueList) {
                skuAttrValue.setSkuId(skuInfo.getId());
            }
            skuAttrValueService.saveBatch(skuAttrValueList);
        }
    }

    /**
     * 根据id获取sku信息
     */
    @Override
    @Transactional
    public SkuInfoVo getSkuInfo(Long id) {
        SkuInfoVo skuInfoVo = new SkuInfoVo();
        // 获取sku商品信息
        SkuInfo skuInfo = baseMapper.selectById(id);
        // 获取sku商品图片
        List<SkuImage> skuImages = skuImageService.getImageListBySkuId(id);
        // 获取sku商品海报
        List<SkuPoster> skuPoster = skuPosterService.getPosterListBySkuId(id);
        // 获取sku商品属性
        List<SkuAttrValue> skuAttrValue = skuAttrValueService.getAttrValueListBySkuId(id);

        BeanUtils.copyProperties(skuInfo, skuInfoVo);
        skuInfoVo.setSkuImagesList(skuImages);
        skuInfoVo.setSkuPosterList(skuPoster);
        skuInfoVo.setSkuAttrValueList(skuAttrValue);
        return skuInfoVo;
    }

    /**
     * 修改sku信息
     */
    @Override
    @Transactional
    public void updateSkuInfo(SkuInfoVo skuInfoVo) {
        // 修改sku商品信息
        SkuInfo skuInfo = new SkuInfo();
        BeanUtils.copyProperties(skuInfoVo, skuInfo);
        baseMapper.updateById(skuInfo);

        Long skuId = skuInfoVo.getId();
        // sku商品海报
        LambdaQueryWrapper<SkuPoster> wrapperSkuPoster = new LambdaQueryWrapper<>();
        wrapperSkuPoster.eq(SkuPoster::getSkuId, skuId);
        skuPosterService.remove(wrapperSkuPoster);

        List<SkuPoster> skuPosterList = skuInfoVo.getSkuPosterList();
        if (!CollectionUtils.isEmpty(skuPosterList)) {
            // 遍历, 添加sku海报,为每个海报添加商品skuId
            for (SkuPoster skuPoster : skuPosterList) {
                skuPoster.setSkuId(skuId);
            }
            skuPosterService.saveBatch(skuPosterList);
        }

        // sku商品图片
        LambdaQueryWrapper<SkuImage> wrapperSkuImage = new LambdaQueryWrapper<>();
        wrapperSkuImage.eq(SkuImage::getSkuId, skuId);
        skuImageService.remove(wrapperSkuImage);

        List<SkuImage> skuImageList = skuInfoVo.getSkuImagesList();
        if (!CollectionUtils.isEmpty(skuImageList)) {
            // 遍历, 添加sku图片,为每个图片添加商品skuId
            for (SkuImage skuImage : skuImageList) {
                skuImage.setSkuId(skuId);
            }
            skuImageService.saveBatch(skuImageList);
        }

        // sku商品属性
        LambdaQueryWrapper<SkuAttrValue> wrapperSkuAttrValue = new LambdaQueryWrapper<>();
        wrapperSkuAttrValue.eq(SkuAttrValue::getSkuId, skuId);
        skuAttrValueService.remove(wrapperSkuAttrValue);

        List<SkuAttrValue> skuAttrValueList = skuInfoVo.getSkuAttrValueList();
        if (!CollectionUtils.isEmpty(skuAttrValueList)) {
            // 遍历, 添加sku属性,为每个属性添加商品skuId
            for (SkuAttrValue skuAttrValue : skuAttrValueList) {
                skuAttrValue.setSkuId(skuId);
            }
            skuAttrValueService.saveBatch(skuAttrValueList);
        }
    }

    /**
     * 上架或下架
     */
    @Override
    public void publish(Long skuId, Integer status) {
        SkuInfo skuInfo = baseMapper.selectById(skuId);
        if (status == 1) {
            // 上架
            skuInfo.setPublishStatus(status);
            //整合mq，同步数据到 es
            rabbitMQService.sendMessage(MqConstant.EXCHANGE_GOODS_DIRECT,
                                        MqConstant.ROUTING_GOODS_UPPER,
                                        skuId);
        } else {
            // 下架
            skuInfo.setPublishStatus(status);
            //整合mq，同步数据到 es
            rabbitMQService.sendMessage(MqConstant.EXCHANGE_GOODS_DIRECT,
                                        MqConstant.ROUTING_GOODS_LOWER,
                                        skuId);
        }
        baseMapper.updateById(skuInfo);
    }

    /**
     * 审核
     */
    @Override
    public void check(Long skuId, Integer status) {
        SkuInfo skuInfo = baseMapper.selectById(skuId);
        skuInfo.setCheckStatus(status);
        baseMapper.updateById(skuInfo);
    }

    /**
     * 新人专享
     */
    @Override
    public void isNewPerson(Long skuId, Integer status) {
        SkuInfo skuInfo = new SkuInfo();
        skuInfo.setId(skuId);
        skuInfo.setIsNewPerson(status);
        baseMapper.updateById(skuInfo);
    }

    // 营销活动相关接口

    /**
     * 根据skuId列表获得sku信息
     * @param skuIdList
     * @return
     */
    @Override
    public List<SkuInfo> findSkuInfoList(List<Long> skuIdList) {
        return baseMapper.selectBatchIds(skuIdList);
    }

    /**
     * 根据关键字查询sku列表
     * @param keyword
     * @return
     */
    @Override
    public List<SkuInfo> findSkuInfoByKeyword(String keyword) {
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(SkuInfo::getSkuName, keyword);
        return baseMapper.selectList(wrapper);
    }

    /**
     * 新人专享
     * @return
     */
    @Override
    public List<SkuInfo> findNewPersonSkuInfoList () {
        // 只显示前3个数据
        Page<SkuInfo> pageParam = new Page<>(1, 3);
        // 创建条件
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SkuInfo::getIsNewPerson, 1);
        wrapper.eq(SkuInfo::getPublishStatus, 1);
        wrapper.orderByDesc(SkuInfo::getStock);
        IPage<SkuInfo> skuInfoPage = baseMapper.selectPage(pageParam, wrapper);
        return skuInfoPage.getRecords();
    }
}
